/** 公用文件,用于检查APP更新，获取网络状态，监听网络状态，存储获取storage等等 */
import API from "@/common/api.js";
import PRSN from "@/js_sdk/wa-permission/permission.js";
import GaodeMap from "@/common/amap-wx.js";
import TIM from 'tim-wx-sdk';
import {
	genTestUserSig
} from '@/sdk/timWx/GenerateTestUserSig.js'

export default {
	mapKey: 'be8fa35efad8ab7dde2097d79061e4c9',

	/**
	 * 获取当前网络类型
	 * @description 获取当前设备所处的网络类型
	 * @return {String} -[none 未联网,wifi wifi网络,ethernet 有线网络,2g,3g,5g,unknow 其他位置网络] 
	 */
	listenerNet() {
		uni.getNetworkType({
			success: res => {
				if (res.networkType == 'none') { //无网络状态
					uni.showToast({
						title: '网络连接已断开',
						icon: "none"
					})
					console.log("未联网");

				} else if (res.networkType != 'wifi' && res.networkType != "ethernet") { //使用移动数据状态
					uni.showToast({
						title: '当前在使用移动数据',
						icon: "none"
					})
					console.log("移动数据网络")

				} else { //wifi和有线状态
					console.log("wifi或有线网络");
				}
				return res.networkType;
			}
		});
	},

	/**
	 * @description 监听网络情况变化
	 */
	netChange() {
		uni.onNetworkStatusChange(() => {
			this.listenerNet();
		});
	},

	/**
	 * @description 更新APP
	 * @param {Object} res 接口传递过来的更新信息
	 */
	updateApp(updateJson) {
		let _this = this;
		let _cachName = '';
		let _downUrl = '';
		if (updateJson.type == 1) { //差量更新
			_cachName = 'wgt-' + updateJson.latest
			_downUrl = updateJson.update_url
		} else { //全量更新
			_cachName = 'pkg-' + updateJson.latest
			_downUrl = updateJson.down_url
		}
		if(uni.getSystemInfoSync().platform=='ios' && updateJson.type==2){		//ios强制更新跳转APPstore
			plus.runtime.openURL('https://apps.apple.com/cn/app/%E6%89%BE%E5%9F%B9%E8%AE%AD%E5%B9%B3%E5%8F%B0/id1505062519');
			return;
		}
		_this.getLocalUpdatePackageByVersion(_cachName).then(storageUrl => { //用接口获取的版本号检查storage缓存
			if (storageUrl) { //有storage缓存
				console.log("有storage缓存" + storageUrl);
				_this.checkSavedUpdatePackage(storageUrl).then(filePath => { //通过storage缓存中的文件路径查看该文件存不存在
					if (filePath) { //存在走安装流程
						console.log("开始安装");
						_this.installUpdatePackage(filePath, updateJson);
		
					} else { //不存在先下载  
						_this.downloadFile(_downUrl,updateJson).then(tempFilePath => { //下载文件
							_this.saveFile(_cachName, tempFilePath).then(savedFilePath => { //存储下载的临时文件
								_this.installUpdatePackage(savedFilePath, updateJson);
							})
						});
					}
				})
			} else { //没有
				_this.downloadFile(_downUrl,updateJson).then(tempFilePath => { //下载文件
					_this.saveFile(_cachName, tempFilePath).then(savedFilePath => { //存储下载的临时文件
						_this.installUpdatePackage(savedFilePath, updateJson);
					})
				});
			}
		})
	},

	/**
	 * 检查已下载的文件中是否有指定文件
	 * @param {String} filePath -文件路径
	 * @return {String} [filePath,undefined]  如果有匹配的文件则返回文件地址，否则返回undefined
	 */
	checkSavedUpdatePackage(filePath) {
		return new Promise((resolve, reject) => {
			uni.getSavedFileList({ //获取已下载的文件
				success: (res) => {
					resolve(res.fileList.find(function(file) { //遍历查询已下载的文件中有没有该文件,有则返回该文件地址，没有则返回undefined
						return file.filePath == filePath
					}))
				},
				fail: (err) => {
					reject(err);
				}
			})
		})
	
	
	},
	/**
	 * @description 安装更新包
	 * @param {Object} filePath
	 */
	installUpdatePackage(filePath, _json) {
		let _this = this;
		plus.runtime.install(filePath, {
			force: true
		}, function() { //安装成功
			uni.setStorageSync("localVersion", _json.latest)
			// _this.removeFile(filePath).then(function() { //安装成功后清除本地文件
	
	
			// });
			
			// uni.showToast({
			// 	title: '安装更新包成功，正在重启应用',
			// 	icon: 'none'
			// });
			setTimeout(() => {
				plus.runtime.restart();
			}, 1500)
	
	
	
		}, function(err) { //安装失败
			// console.log(err);
			// uni.showToast({
			// 	title: '本地安装包已损坏正在重新下载',
			// 	icon: 'none'
			// });
			let _cachName = '';
			let _downUrl = '';
			if (_json.type == 1) { //差量更新
				_cachName = 'wgt-' + _json.latest
				_downUrl = _json.update_url
			} else { //全量更新
				_cachName = 'pkg-' + _json.latest
				_downUrl = _json.down_url
			}
			_this.downloadFile(_downUrl,_json).then(tempFilePath => { //下载文件
				_this.saveFile(_cachName, tempFilePath).then(savedFilePath => { //存储下载的临时文件
					_this.installUpdatePackage(savedFilePath, _json);
				})
			});
		});
	},
	
	/**
	 * @description 下载文件
	 * @param {Object} fileUrl=[需要下载的文件url]
	 * @example  https://www.hawklu.com/testPage/ranking.apk
	 */
	downloadFile(fileUrl,_json) {
		let _this = this;
		return new Promise((resolve, reject) => {
			console.log(fileUrl);
			const downloadTask = uni.downloadFile({
				url: fileUrl,
				success: (res) => {
					if (res.statusCode === 200) {
						console.log("文件下载成功，暂存地址:" + res.tempFilePath);
						resolve(res.tempFilePath);
	
					} else {
						uni.showModal({
							title: '更新失败',
							content: '安装包下载失败，请检查网络或重启应用试试',
							showCancel: false,
							cancelText: '',
							confirmText: '确定',
							success: res => {},
							fail: () => {},
							complete: () => {
								plus.runtime.quit();
							}
						});
						reject(res);
					}
				},
				fail: err => {
					uni.showModal({
						title: '更新失败',
						content: '安装包下载失败，请检查网络或重启应用试试',
						showCancel: false,
						cancelText: '',
						confirmText: '确定',
						success: res => {},
						fail: () => {},
						complete: () => {
							plus.runtime.quit();
						}
					});
				}
			});
	
			// 下载中处理
			downloadTask.onProgressUpdate((res) => {
				// uni.showLoading({
				// 	title: '正在下载中...'+res.progress+'%',
				// 	mask: false
				// });
				if(_json.type==2){
					uni.$emit("downing", res);
				}
				// console.log('下载进度' + res.progress);
				// console.log('已经下载的数据长度' + res.totalBytesWritten);
				// console.log('预期需要下载的数据总长度' + res.totalBytesExpectedToWrite);
				// 测试条件，取消下载任务。
	
			});
		})
	
	},
	/**
	 * @description 存储下载的文件
	 * @param {Object} tempFile  下载后暂存的文件路径，暂存文件在APP重启后会消失
	 * @param {String} version 安装包的版本号 
	 */
	saveFile(version, tempFilePath) {
		return new Promise((resolve, reject) => {
			uni.saveFile({
				tempFilePath: tempFilePath,
				success: function(res) {
					uni.setStorage({
						key: version,
						data: res.savedFilePath,
						success() {
							console.log("存储文件成功，存储地址：" + res.savedFilePath);
							resolve(res.savedFilePath);
						}
					})
				},
				fail: (err) => {
					console.log("存储文件失败");
				}
			});
		})
	
	},
	
	/**
	 * @description 通过版本号检查storage
	 * @param {Object} version
	 */
	getLocalUpdatePackageByVersion(version) {
		return new Promise((resolve, reject) => {
			uni.getStorage({
				key: version,
				success: (storageRes) => {
					resolve(storageRes.data)
				},
				fail() {
					console.log("通过版本号没有获取到文件");
					resolve(false);
				}
			})
		})
	},
	
	/**
	 * @param {Object} filePath 文件的路径
	 */
	removeFile(filePath) {
		return new Promise((resolve, reject) => {
			uni.removeSavedFile({
				filePath: filePath,
				success: () => {
					resolve()
				},
				fail: (reject) => {
					reject()
				},
				complete: function(res) {
					console.log(res);
				}
			});
		})
	},
	/**
	 * 获取下载目录所有的文件总大小
	 */
	getDownloadListSize() {
		let downloadSize = 0;
		let _this = this;
		return new Promise(resolve => {
			uni.getSavedFileList({
				success: (res) => {
					downloadSize = res.fileList.reduce(function(x, y) {
						return Number(x) + Number(y.size)
					}, 0);
					resolve(_this.bytesToSize(downloadSize));
				},
				fail: () => {
					console.log("获取下载目录文件总大小失败");
				}
			})
		})
	},
	async clearDownLoadFile(_fileArr){
		let _this=this;;
		uni.showLoading({
			title: '清除缓存中...',
			mask: false
		});
		
		if(_fileArr.length>0){
			for(let i=0;i<_fileArr.length;i++){
				await _this.removeFile(_fileArr[i].filePath)
			}
		}
		// uni.clearStorageSync();
		setTimeout(()=>{
			uni.hideLoading()
		},1500)
		console.log("清理完毕");
	},
	
	/**
	 * @description 字节数转换为 B，KB，MB等
	 * @param {Object} bytes
	 * @return {String}
	 */
	bytesToSize(bytes) {
		if (bytes === 0) return '0 B';
		let k = 1024,
			sizes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],
			i = Math.floor(Math.log(bytes) / Math.log(k));
		return (bytes / Math.pow(k, i)).toFixed(2) + ' ' + sizes[i];
	},
	/**
	 * @description 将对象转化为URL后的参数，注意只能转化单层对象
	 * @param {Object} params 
	 * @return {String} 转化后的字符串
	 * @example paramsURL({id:123,name:'张三'})   =>  id=123&name=张三
	 */
	paramsURL(params) {
		let newParams = params;
		let newURL = '';


		for (const [key, val] of Object.entries(newParams || {})) {
			newURL += `${key}=${val}&`;
		}

		return newURL.substring(0, newURL.length - 1);
	},
	/**
	 * @description  带参url转换为object
	 * @param {Object} str  URL
	 * @return {Object}
	 */
	pramsUrlToObj(str) {
		let obj = {
			url: ''
		};
		let opt = {};
		if (str.split("?") < 1) {
			obj = {
				url: str
			}
		} else {
			var arr = str.split("?");
			obj = {
				url: arr[0]
			}
			if (arr[1]) {
				var arr2 = arr[1].split("&");
				for (var i = 0; i < arr2.length; i++) {
					var res = arr2[i].split("=");
					opt[res[0]] = res[1];
				}
			}
		}
		obj.opt = opt;
		return obj;
	},
	innerUrlToObj(str){
		let obj = {
			url: ''
		};
		if (str.split("?") < 1) {
			obj = {
				url: str
			}
		} else {
			var arr = str.split("?");
			obj = {
				url: arr[0]
			}
			if (arr[1]) {
				var arr2 = arr[1].split("&");
				for (var i = 0; i < arr2.length; i++) {
					var res = arr2[i].split("=");
					obj[res[0]] = res[1];
				}
			}
		}
		return obj;
	},
	/**
	 * @description  字符串转对象
	 * @param {Object} str
	 */
	strToObj(str) {
		let opt = {};
		var arr2 = str.split("&");
		for (var i = 0; i < arr2.length; i++) {
			var res = arr2[i].split("=");
			opt[res[0]] = res[1];
		}
		return opt;
	},
	/**
	 * @description 从本地缓存中同步获取指定 key 对应的内容。
	 * @param {String} key
	 */
	getStorage(key) {
		return uni.getStorageSync(key);
	},
	/**
	 * @description  设置storage
	 * @param {string} key
	 * @param {Object} val
	 */
	setStorage(key, val) {
		uni.setStorageSync(key, val);
	},
	/**
	 * @description 权限检查,当前APP用到了位置,推送,摄像头,定位,相册读写
	 * @param {String} prsn	需要检查的权限字符串
	 * location	位置
	 * push	推送
	 * camera	摄像头
	 * photoLibrary	相册
	 * record	麦克风
	 * contact	通讯录
	 * calendar	日历
	 * memo	备忘录
	 * call 拨打电话
	 */
	chackAppSinglePRSN(prsnStr) {
		return new Promise((resolve) => {
			// #ifdef APP-PLUS
			let sys = uni.getSystemInfoSync().platform;
			if (prsnStr == "location") {
				if (sys == "ios") { //苹果手机
					resolve(PRSN.judgeIosPermission("location") ? 1 : 0)
				} else { //安卓手机

					PRSN.requestAndroidPermission('android.permission.ACCESS_FINE_LOCATION').then(res => {
						resolve(res);
					});

				}
			} else if (prsnStr == "push") {
				if (sye == 'ios') {
					resolve(PRSN.judgeIosPermission("push") ? 1 : 0)
				} else {
					var main = plus.android.runtimeMainActivity();
					var NotificationManagerCompat = plus.android.importClass("android.support.v4.app.NotificationManagerCompat");
					var areNotificationsEnabled = NotificationManagerCompat.from(main).areNotificationsEnabled();
					if (areNotificationsEnabled) {
						resolve(1)
					} else {
						resolve(0)
					}
				}
			} else if (prsnStr == "camera") {
				if (sys == "ios") {
					resolve(PRSN.judgeIosPermission("camera") ? 1 : 0)
				} else {
					PRSN.requestAndroidPermission('android.permission.CAMERA').then(res => {
						resolve(res);
					});
				}
			} else if (prsnStr == "photoLibrary") {

			} else if (prsnStr == "call") {
				if (sys == "ios") { //苹果手机
					resolve(1); //苹果手机默认有拨打电话权限
				} else { //安卓手机
					PRSN.requestAndroidPermission('android.permission.CALL_PHONE').then(res => {
						resolve(res);
					});
				}
			} else {

			}
			// #endif

			// #ifdef MP-WEIXIN

			// #endif

		})

	},
	/**
	 * @description 拨打电话,拨打前会检查权限
	 * @param {Object} tel
	 */
	callPhone(tel) {
		// #ifdef APP-PLUS
		this.chackAppSinglePRSN("call").then(res => {
			if (res == -1) {
				uni.showModal({
					title: '权限申请',
					content: '拨打电话权限已被禁止，请授权后重试',
					showCancel: false,
					cancelText: '',
					confirmText: '确定',
					success: rlt => {
						if (rlt.confirm) {
							PRSN.gotoAppPermissionSetting();
						}
					},
				});

			} else {
				uni.makePhoneCall({
					phoneNumber: tel
				});
			}
		})
		// #endif

		// #ifdef MP
		uni.makePhoneCall({
			phoneNumber: tel
		});
		// #endif
	},
	/**
	 * @description 唤起相机扫描二维码
	 */
	scanCode() {
		return new Promise((resolve, reactiv) => {
			this.chackAppSinglePRSN('camera').then(pres => {
				console.log(pres);
				if (pres == 0) {
					uni.scanCode({
						onlyFromCamera: true,
						success: function(res) {
							resolve(res)
						},
						fail: function(e) {
							reactiv(e)
							console.log(e);
						}
					});
				} else if (pres != 1) {
					uni.showModal({
						title: '权限申请',
						content: '相机权限已被禁止，请授权后重试',
						showCancel: false,
						cancelText: '',
						confirmText: '确定',
						success: res => {
							PRSN.gotoAppPermissionSetting();
						},
						fail: () => {},
						complete: () => {}
					});
				} else {
					uni.scanCode({
						onlyFromCamera: true,
						success: function(res) {
							resolve(res)
						},
						fail: function(e) {
							reactiv(e)
							console.log(e);
						}
					});
				}
			})
		})
	},

	/**
	 * @description 通过经纬度坐标打开地图
	 * @param {Object} shopData 店铺经纬度坐标
	 */
	toMapBylng(shopData) {
		// #ifdef APP-PLUS
		this.chackAppSinglePRSN("location").then(res => {
			if (res == -1) {
				uni.showModal({
					title: '权限申请',
					content: '获取位置权限已被禁止，请授权后重试',
					showCancel: false,
					cancelText: '',
					confirmText: '确定',
					success: rlt => {
						if (rlt.confirm) {
							PRSN.gotoAppPermissionSetting();
						}
					},
				});
			} else {
				uni.openLocation({
					latitude: 32.0406992940,
					longitude: 118.7944525480,
					name: "智力网络",
					address: "长安国际中心2404",
					success: function() {
						console.log('success');
					}
				});
			}
		});
		// #endif

		// #ifdef MP
		uni.openLocation({
			latitude: 32.0406992940,
			longitude: 118.7944525480,
			name: "智力网络",
			address: "长安国际中心2404",
			success: function() {
				console.log('success');
			}
		});
		// #endif

		// #ifdef H5
		// #endif
	},
	getSSQbyLocation() {
		return new Promise(resolve => {
			let _this = this;
			this.chackAppSinglePRSN("location").then(res => {
				if (res == -1) {
					uni.showModal({
						title: '权限申请',
						content: '获取位置权限已被禁止，请授权后重试',
						showCancel: false,
						cancelText: '',
						confirmText: '确定',
						success: rlt => {
							if (rlt.confirm) {
								PRSN.gotoAppPermissionSetting();
							}
						},
					});
				} else {
					let amapPlugin = new GaodeMap.AMapWX({
						key: _this.mapKey
					});
					amapPlugin.getRegeo({
						success: data => {
							resolve(data)

						},
						fail: info => {
							//失败回调
							console.log(info)
						}
					});
				}
			});
		})

	},
	/**
	 * @description 创建本地推送消息
	 * @param {Object} msg
	 * msg 字段
	 * title push消息标题
	 * content push消息内容
	 * payload push消息参数
	 */
	createLocalMsg(msg) {
		plus.push.createMessage(msg.content, this.paramsURL(msg.payload), {
			title: msg.title,
			delay: 0,
			sound: 'system'
		})
	},
	/**
	 * @description  TIM登录
	 * @param {String} userName
	 */
	timLogin(userName, _this) {
		return new Promise(resolve => {

			let sigUser = genTestUserSig(userName); //获取签名正式发布需要部署到服务器从接口获取,TODO

			_this.$tim.login({
				userID: userName,
				userSig: sigUser.userSig
			}).then(res => {
				resolve(res)
			})

		})
	},
	/**
	 * @description  更新TIM用户个人资料
	 * @param {Object} opt
	 * opt 字段说明
	 * nick 昵称 string
	 * avatar 头像地址 string
	 * gender 性别 string
	 * allowType 添加好友是否需要验证  string
	 * messageSettings 消息设置   0接收消息 ,1不接收消息
	 */
	timUpdateUserInfo(opt, _this) {
		return new Promise(resolve => {
			_this.$tim.updateMyProfile(opt).then(res => {
				resolve(res)
			})
		})
	},
	/**
	 * @description 获取消息列表
	 * @param {Object} opt
	 * @param {Object} _this 
	 * opt 字段说明
	 * conversationID 会话ID  string
	 * nextReqMessageID 分页  第一次拉取可不传  number
	 * count 每次拉取多少条,最大为15  number
	 */
	timGetMsgList(opt, _this) {
		return new Promise(resolve => {
			_this.$tim.getMessageList(opt).then(res => {
				resolve(res)
			})
		})
	},
	/**
	 * tim发送文本消息
	 * @param {String} toUser  发送给目标用户的ID
	 * @param {String} text    文本内容
	 * @param {Object} _this
	 */
	timSendText(toUser, text, _this) {
		return new Promise((sucess, fail) => {
			var msg = _this.$tim.createTextMessage({
				to: toUser,
				conversationType: TIM.TYPES.CONV_C2C,
				payload: {
					text: text
				}
			})
			_this.$tim.sendMessage(msg).then(res => {
				sucess(res)
			}).catch(err => {
				fail(err)
			})
		})
	},
	/**
	 * @description  TIM发送图片消息
	 * @param {String} toUser  发送目标用户ID
	 * @param {Object} imgPath	图片路径,
	 * @param {Object} _this	
	 */
	timSendImg(toUser, imgPath, _this) {
		return new Promise((sucess, fail) => {
			let msg = _this.$tim.createImageMessage({
				to: toUser,
				conversationType: TIM.TYPES.CONV_C2C,
				payload: {
					file: imgPath,
				},
			});
			_this.$tim.sendMessage(msg).then(res => {
				sucess(res)
			}).catch(err => {
				fail(err)
			})
		})
	},
	/**
	 * @description  TIM发送自定义消息
	 * @param {Object} toUser
	 * @param {Object} opt
	 * @param {Object} _this
	 * opt 字段
	 * data  
	 * description
	 * extension
	 */
	timSendZdMsg(toUser, opt, _this) {
		return new Promise((sucess, fail) => {
			let msg = _this.$tim.createCustomMessage({
				to: toUser,
				conversationType: TIM.TYPES.CONV_C2C,
				payload: opt,
			});
			_this.$tim.sendMessage(msg).then(res => {
				sucess(res)
			}).catch(err => {
				fail(err)
			})
		})
	},
	/**
	 * TIM获取用户资料
	 * @param {Object} userIdArr
	 */
	timGetUserInfo(userIdArr, _this) {
		console.log(userIdArr);
		return new Promise((sucess, fail) => {
			_this.$tim.getUserProfile({
				userIDList: userIdArr
			}).then(res => {
				sucess(res)
			}).catch(err => {
				fail(err)
			})
		})
	},
	/**
	 * @description TIM获取会话列表
	 * @param {Object} _this
	 */
	timGetCovList(_this){
		return new Promise(resolve=>{
			_this.$tim.getConversationList().then(res=>{
				resolve(res.data.conversationList)
			})
		})
	},
	/**
	 * @description TIM退出登录
	 * @param {Object} _this
	 */
	timLogOut(_this){
		let promise =_this.$tim.logout();
		promise.then(function(imResponse) {
		  console.log(imResponse.data); // 登出成功
		}).catch(function(imError) {
		  console.warn('logout error:', imError);
		});

	},
	/**
	 * @description 通过页面名检查页面是否已经打开
	 * @param {Object} pageName
	 * @return {Number} 如果已经打开过,返回回退需要的back数
	 */
	checkPageOpendByName(pageName) {
		let lastOpenIndex = 0; //最后一次打开index
		let openCount = 0; //已打开的数量
		let pageArr = getCurrentPages(); //获取页面栈数组
		let firstOpendIndex = 0; //第一次打开index
		//遍历页面栈,获取最后一次打开同名的index和已打开同名页面的数量
		pageArr.forEach(function(v, i) {
			//数组中判断是否有此页面  注意这边用的是array.indexOf方法
			let opd = v.route.split('/').indexOf(pageName) > 0;
			if (opd) {
				lastOpenIndex = i;
				openCount++;
				if (firstOpendIndex == 0) {
					firstOpendIndex = i;
				}
			}
		});
		return {
			opendCount: openCount, //已打开页面数
			lastOpendIndex: lastOpenIndex, //最后一次打开index
			firstOpendIndex: firstOpendIndex, //第一次打开index
			backLastLength: pageArr.length - lastOpenIndex - 1,
			backFirstLength: pageArr.length - firstOpendIndex - 1,
			pageCount: pageArr.length
		}
	},
	/**
	 * @description 检查用户信息
	 * @param {Object} _this
	 */
	checkUserInfo(userId, _this) {

		API.getSettledById(userId).then(res => { //获取入驻进度
			if (res.data.data.status == 0) { //如果未提交跳转到认证
				// _this.toPage({
				// 	url: 'addSettled',
				// })
				_this.toPage({
					url: 'selectShop',
				})
			} else if (res.data.data.status == 2 || res.data.data.status == 1) { //如果审核被拒绝跳转到进度
				// _this.toPage({
				// 	url: 'settledProgress',
				// })
				_this.toPage({
					url: 'selectShop',
				})
			} else if (res.data.data.status == 3) { //如果审核通过,获取店铺
				API.getShopListByUserId(userId).then(shopRes => {
					_this.toPage({
						url: 'selectShop',
					})
				})

			} else {

			}
		})


	},
	/**
	 * @description  更新缓存中的用户信息
	 * @param {Object} key
	 * @param {Object} val
	 */
	updateUserInfo(key, val) {
		let _userInfo = uni.getStorageSync("userInfo")
		_userInfo[key] = val
		uni.setStorageSync("userInfo", _userInfo);
	},
	/**
	 * @description 用户退出登录
	 */
	userSignOut(_this) {
		API.logOut(uni.getStorageSync("userInfo").token).then(res => {
			uni.removeStorageSync("userInfo");
			_this.toPage({
				url: 'login'
			})
		})

	},
	
}
